// pages/questionBank/questionBank.js
Page({

  /**
   * 页面的初始数据
   */
  data: {
    activeSidebar: 'chapter', // 当前激活的侧边栏项，默认显示章节练习
    searchKey: '', // 搜索关键词
    
    // 从API获取的题库数据
    questionBankList: [],
    loading: false, // 加载状态
    pageNum: 1, // 当前页码
    pageSize: 10, // 每页数量
    total: 0, // 总数量
    currentSubjectId: null, // 当前选中的科目ID
    
    // 分类后的题库数据
    chapterPracticeList: [], // 章节练习 (type=OFFICIAL)
    mockExamList: [], // 模拟考试 (type=CUSTOM)
    realExamList: [], // 真题练习 (type=EXCLUSIVE)
    
    // 按课程分组的章节练习数据
    groupedChapterPractice: []
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('页面加载开始');
    // 1. 获取全局科目ID
    const subjectId = this.getCurrentSubjectId();
    
    // 2. 如果有科目ID，立即加载题库数据
    if (subjectId) {
      this.loadQuestionBankList();
    } else {
      console.log('未获取到科目ID，无法加载题库数据');
    }
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 检查科目ID是否发生变化，如果变化则重新加载数据
    const currentSubjectId = this.getCurrentSubjectId();
    if (currentSubjectId !== this.data.currentSubjectId) {
      console.log('科目ID发生变化，重新加载数据');
      this.setData({
        currentSubjectId: currentSubjectId
      });
      // 重新加载题库数据
      this.loadQuestionBankList();
    }
  },

  // 切换侧边栏
  switchSidebar(e) {
    const type = e.currentTarget.dataset.type;
    this.setData({
      activeSidebar: type,
      pageNum: 1 // 切换侧边栏时重置页码
    });
    
    // 如果在搜索状态下，不重新调用接口，直接使用当前搜索结果
    if (this.data.searchKey && this.data.searchKey.trim() !== '') {
      console.log('搜索状态下切换标签，使用当前搜索结果');
      return;
    }
    
    // 非搜索状态下，保持在当前页面，根据类型展示不同内容
    this.loadQuestionBankList();
  },

  // 搜索输入处理
  onSearchInput(e) {
    const searchKey = e.detail.value;
    this.setData({
      searchKey: searchKey
    });
    
    // 如果搜索关键词为空，清除搜索状态并重新加载所有数据
    if (!searchKey || searchKey.trim() === '') {
      console.log('搜索关键词为空，清除搜索状态并重新加载所有数据');
      this.clearSearchAndReload();
    }
  },

  // 搜索确认（回车键）
  onSearchConfirm(e) {
    const searchKey = e.detail.value;
    console.log('搜索确认，关键词:', searchKey);
    
    if (!searchKey || searchKey.trim() === '') {
      console.log('搜索关键词为空，重新加载所有数据');
      this.clearSearchAndReload();
      return;
    }
    
    // 调用搜索接口
    this.searchQuestionBanks(searchKey);
  },

  // 进入具体题库
  goToQuestionBank(e) {
    const questionBank = e.currentTarget.dataset.questionBank;
    console.log('点击题库:', questionBank);
    
    // 跳转到index/pages/questionBank/questionBank页面，只传递题库ID
    wx.navigateTo({
      url: `/index/pages/questionBank/questionBank?questionBankId=${questionBank.id}`
    });
  },

  // 进入课程题库
  goToCourseQuestionBank(e) {
    const course = e.currentTarget.dataset.course;
    console.log('进入课程题库:', course);
    
    // 跳转到index/pages/questionBank/questionBank页面，只传递题库ID
    // 这里假设course中有题库ID，如果没有则使用第一个题库的ID
    if (course.questionBanks && course.questionBanks.length > 0) {
      const firstQuestionBank = course.questionBanks[0];
      wx.navigateTo({
        url: `/index/pages/questionBank/questionBank?questionBankId=${firstQuestionBank.id}`
      });
    } else {
      wx.showToast({
        title: '该课程暂无题库',
        icon: 'none'
      });
    }
  },

  // 进入名词解释
  goToTermExplanation(e) {
    const course = e.currentTarget.dataset.course;
    console.log('查看名词解释:', course);
    
    wx.showToast({
      title: `查看${course.courseName}名词解释`,
      icon: 'none'
    });
    // 这里可以添加跳转逻辑，传递课程信息
  },

  // 获取当前选中的科目ID
  getCurrentSubjectId() {
    try {
      // 从utils/subject.js获取科目ID
      const { getSelectedSubjectId } = require('../../utils/subject.js');
      const subjectId = getSelectedSubjectId();
      
      if (subjectId) {
        console.log('从工具类获取到科目ID:', subjectId);
        this.setData({
          currentSubjectId: subjectId
        });
        return subjectId;
      } else {
        console.log('工具类中没有科目ID，尝试从本地存储获取');
        // 备用方案：从本地存储获取
        const storedSubjectId = wx.getStorageSync('selectedSubjectId');
        this.setData({
          currentSubjectId: storedSubjectId
        });
        return storedSubjectId;
      }
    } catch (error) {
      console.error('获取科目ID失败:', error);
      // 备用方案：从本地存储获取
      const storedSubjectId = wx.getStorageSync('selectedSubjectId');
      this.setData({
        currentSubjectId: storedSubjectId
      });
      return storedSubjectId;
    }
  },

  // 加载题库列表
  loadQuestionBankList() {
    const subjectId = this.getCurrentSubjectId();
    console.log('=== 开始加载题库列表 ===');
    console.log('当前科目ID:', subjectId);
    console.log('当前页码:', this.data.pageNum);
    console.log('每页数量:', this.data.pageSize);
    
    if (!subjectId) {
      console.log('❌ 科目ID为空，无法加载题库');
      wx.showToast({
        title: '请先选择科目',
        icon: 'none'
      });
      return;
    }

    console.log('✅ 科目ID有效，开始请求接口');
    this.setData({
      loading: true
    });

    // 引入http工具类
    const { http } = require('../../utils/http');
    
    // 调用题库列表接口 - 使用相对路径，http.js会自动添加BASE_URL
    const apiUrl = '/fk/question_bank/list';
    const params = {
      subjectId: subjectId,
      pageNum: this.data.pageNum,
      pageSize: this.data.pageSize
    };
    
    console.log('🌐 请求接口:', apiUrl);
    console.log('📝 请求参数:', params);
    
    http.get(apiUrl, params)
    .then(res => {
      console.log('✅ 接口请求成功:', res);
      
      if (res && res.code === 200 && res.rows) {
        console.log('✅ 数据格式正确，开始处理数据');
        // 更新总数量和题库列表
        this.setData({
          total: res.total || 0,
          questionBankList: res.rows
        });

        // 3. 根据type值进行分类
        this.classifyQuestionBanks(res.rows);
        
        // 4. 章节练习按课程进一步细分
        this.processChapterPracticeData(res.rows);
        
        console.log('✅ 数据处理完成，题库总数:', res.rows.length);
      } else {
        console.log('❌ API返回数据格式异常:', res);
        wx.showToast({
          title: '数据格式错误',
          icon: 'none'
        });
      }
    })
    .catch(err => {
      console.error('❌ 获取题库列表失败:', err);
      wx.showToast({
        title: '获取题库失败',
        icon: 'none'
      });
    })
    .finally(() => {
      this.setData({
        loading: false
      });
      console.log('🏁 数据加载完成');
    });
  },

  // 搜索题库
  searchQuestionBanks(searchKey) {
    const subjectId = this.getCurrentSubjectId();
    console.log('=== 开始搜索题库 ===');
    console.log('搜索关键词:', searchKey);
    console.log('当前科目ID:', subjectId);
    
    if (!subjectId) {
      console.log('❌ 科目ID为空，无法搜索题库');
      wx.showToast({
        title: '请先选择科目',
        icon: 'none'
      });
      return;
    }

    console.log('✅ 科目ID有效，开始搜索');
    this.setData({
      loading: true
    });

    // 引入http工具类
    const { http } = require('../../utils/http');
    
    // 调用相同的接口，添加搜索参数
    const apiUrl = '/fk/question_bank/list';
    const params = {
      subjectId: subjectId,
      pageNum: 1, // 搜索时重置为第一页
      pageSize: this.data.pageSize,
      name: searchKey // 添加搜索关键词参数
    };
    
    console.log('🔍 搜索接口:', apiUrl);
    console.log('🔍 搜索参数:', params);
    
    http.get(apiUrl, params)
    .then(res => {
      console.log('✅ 搜索接口请求成功:', res);
      
      if (res && res.code === 200 && res.rows) {
        console.log('✅ 搜索结果数据格式正确，开始处理数据');
        // 更新总数量和题库列表
        this.setData({
          total: res.total || 0,
          questionBankList: res.rows,
          pageNum: 1 // 搜索后重置页码
        });

        // 根据type值进行分类
        this.classifyQuestionBanks(res.rows);
        
        // 章节练习按课程进一步细分
        this.processChapterPracticeData(res.rows);
        
        console.log('✅ 搜索结果处理完成，题库总数:', res.rows.length);
        
        // 显示搜索结果提示
        wx.showToast({
          title: `找到${res.rows.length}个题库`,
          icon: 'none',
          duration: 1500
        });
      } else {
        console.log('❌ 搜索接口返回数据格式异常:', res);
        // 搜索无结果时，清空数据
        this.setData({
          total: 0,
          questionBankList: [],
          chapterPracticeList: [],
          mockExamList: [],
          realExamList: [],
          groupedChapterPractice: []
        });
        
        wx.showToast({
          title: '未找到相关题库',
          icon: 'none'
        });
      }
    })
    .catch(err => {
      console.error('❌ 搜索题库失败:', err);
      wx.showToast({
        title: '搜索失败',
        icon: 'none'
      });
    })
    .finally(() => {
      this.setData({
        loading: false
      });
      console.log('🏁 搜索完成');
    });
  },

  // 清除搜索状态并重新加载数据
  clearSearchAndReload() {
    console.log('清除搜索状态，重新加载所有数据');
    this.setData({
      searchKey: '',
      pageNum: 1
    });
    this.loadQuestionBankList();
  },

  // 根据type分类题库数据
  classifyQuestionBanks(questionBanks) {
    const chapterPractice = [];
    const mockExam = [];
    const realExam = [];

    questionBanks.forEach(item => {
      // 确保每个数据都包含题库ID
      if (!item.id) {
        console.warn('题库数据缺少ID:', item);
      }
      
      switch (item.type) {
        case 'OFFICIAL':
          chapterPractice.push(item);
          break;
        case 'CUSTOM':
          mockExam.push(item);
          break;
        case 'EXCLUSIVE':
          realExam.push(item);
          break;
        default:
          // 未知类型，默认放入章节练习
          console.log('未知类型，默认放入章节练习:', item.type);
          chapterPractice.push(item);
          break;
      }
    });

    this.setData({
      chapterPracticeList: chapterPractice,
      mockExamList: mockExam,
      realExamList: realExam
    });

    console.log('题库分类完成:', {
      chapterPractice: chapterPractice.length,
      mockExam: mockExam.length,
      realExam: realExam.length
    });
  },

  // 处理章节练习数据，按课程分组
  processChapterPracticeData(questionBanks) {
    // 只处理章节练习类型的数据
    const chapterPracticeData = questionBanks.filter(item => item.type === 'OFFICIAL');
    
    // 按课程分组
    const courseGroups = {};
    
    chapterPracticeData.forEach(item => {
      if (item.courseName) {
        if (!courseGroups[item.courseName]) {
          courseGroups[item.courseName] = {
            courseName: item.courseName,
            questionBanks: []
          };
        }
        // 确保包含题库ID
        courseGroups[item.courseName].questionBanks.push({
          ...item,
          questionBankId: item.id // 绑定题库ID
        });
      }
    });

    const groupedData = Object.values(courseGroups);
    
    this.setData({
      groupedChapterPractice: groupedData
    });

    console.log('章节练习分组完成:', groupedData);
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    // 下拉刷新逻辑（如重新加载数据）
    this.setData({
      pageNum: 1
    });
    this.loadQuestionBankList();
    wx.stopPullDownRefresh();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    // 上拉加载更多逻辑
    if (this.data.questionBankList.length < this.data.total) {
      this.loadMoreQuestionBank();
    }
  },

  // 加载更多题库
  loadMoreQuestionBank() {
    if (this.data.loading) return;
    
    this.setData({
      pageNum: this.data.pageNum + 1
    });
    
    this.loadQuestionBankList();
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: '题库',
      path: '/pages/questionBank/questionBank'
    };
  }
});
